<!doctype html>
<html>
<head>
<meta charset="utf-8">
<title>test</title>
<script>


//【示例1】下面看一个示例：
function f(){
    this.x=function(x){ 		// 使用this关键字为函数定义一个方法x()
        return x
    }
}
f();							// 调用函数
alert(f.x(4)); 					// 使用函数f名调用方法x()，则返回编译错误

alert(window.x(4)); 			// 使用window对象调用方法x()，则返回4
//【示例2】当使用new运算符调用函数，则this将指向实例对象，在下面代码中变量a就成为this指代对象，此时调用方法x()就不能够使用window对象。
function f(){
    this.x=function(x){ 		// 使用this关键字为函数定义一个方法x()
        return x
    }
}
// 使用new----运算符实例化函数f，并把实例化对象赋值给变量a，则a就拥有函数f的结构。
var a = new f();
alert(a.x(4));				 	// 使用对象a调用方法x()，则返回4

alert(window.x(4)); 			// 提示编译错误
//【示例3】利用this可以为调用对象定义属性。
var x =1; 						// 声明变量x为1
function f(){
    this.x = 2; 				// 声明当前对象的属性x为2
}
alert(x) 						// 返回1

var x =1; 						// 声明变量x为1
function f(){
    this.x = 2; 				// 声明当前对象的属性x为2
}
f();							// 调用函数f
alert(x) 						// 返回2
//【示例4】在全局作用域内，所有变量和函数的调用对象都是window，对于上面示例可以这样设计。
window.x =1;
function f(){
    this.x = 2;
}
window.f(); 
alert(window.x); 				// 返回2
//【示例5】在下面示例中先调用isNaN()方法，然后在函数f体内使用tihs重写isNaN()方法，在全局作用域中调用函数f，然后再调用isNaN()方法，则返回值永远是false。
alert(isNaN(NaN)); 				// 返回true
function f() {
    this.isNaN = function() {
        return false;
    };
}
f();
alert(isNaN(NaN)); 				// 返回false
//【示例6】下面示例演示了嵌套函数结构体内this的变化规律。
function f(){
    this.a = " a ";				// 属于window对象所有
    alert( this.a + this.b + this.c + this.d ); 
	// 返回a undefined undefined undefined
    e();						// f函数域内调用，属于window对象所有
    function e(){
        this.b = " b ";
        alert( this.a + this.b + this.c + this.d ); 
				// 返回a b undefined undefined
        g();		// e函数域内调用，属于window对象所有
        function g(){
            this.c = " c ";
            alert( this.a + this.b + this.c + this.d );
 				// 返回a b c undefined
            h();	// g函数域内调用，属于window对象所有
            function h(){
                this.d = " d ";
                alert( this.a + this.b + this.c + this.d );
 				// 返回a b c d
            }
        }
    }
}
f();			// 在全局作用域内调用函数f，，属于window对象所有
//【示例7】对于上面函数嵌套结构，如果不通过函数调用的方式来执行，而是通过对象实例化的方式来激活，则发现this指向的对象完全不同。
function f(){
    this.a = " a ";				// 属于对象f所有
    alert( this.a + this.b + this.c + this.d ); 
		// 返回a undefined undefined undefined
    var x = new e();			// 实例化对象e
    function e(){
        this.b = " b ";			// 属于对象e所有
        alert( this.a + this.b + this.c + this.d ); 
			// 返回undefined b undefined undefined
        var x = new g();			// 实例化对象g
        function g(){
            this.c = " c ";		// 属于对象g所有
            alert( this.a + this.b + this.c + this.d ); 
    			// 返回NaN c undefined
            var x = new h();		// 实例化对象h
            function h(){
                this.d = " d ";	// 属于对象h所有
                alert( this.a + this.b + this.c + this.d );// 返回NaN d
            }
        }
    }
}
var x = new f();				// 实例化对象f






</script>
</head>
<body>




</body>
</html>
